Object Oriented Programming Issues
Programming
errors are a common issue with any programming practice. In case of Object
Oriented Programming such error might be because of considering the type of
object instead of the membership it is associated with. When this happens,
the advantages of polymorphism and inheritance are weakened.
Many such errors arise
while creating an application with an object oriented programming approach.
OOP supports code centrality, which is connected to inheritance. Code
centrality makes the code more expensive to maintain.
The costs involved with maintaining code can become high when large
applications are involved, even more serious while involved at higher levels
of the system. Usually developers who are maintaining lower level classes
avoid to make changes in the code in order to correct a bug. These developers
ask someone else to fix the issue. However, code centrality can be obtained
with techniques which are secure. Another issue related to OOP is that lists
of exclusive options may not match changes that occur within the real world.
However, OOP techniques like "composition" can be helpful in
solving many such problems. Yet, the composition technique resembles network
data structures, and it may not be a good alternative. Another way to avoid
this is to look at only the specific objects that are available, and model
relationships among them. It is to be noted that there could be complications
between inheritance and polymorphism. Using the relational model might be
better because it has a mathematical structure which is based on relational
calculus and predicate calculus. Unfortunately, OOP does not have a structure
which is based on mathematical models.
Another issue to be noted is that object oriented programming resembles the navigational
database systems that were used during the 1960s. According to this class of
users the relational database is merely a replacement. However, this is not
necessarily the aim of OOP. Relational database modeling is based on premises
which are different from those that OOP is based on. However, there are
connections between the two because relational database tables are used with
OOP models.
Yet another issue that arises for OOPs is that of necessity of copying.
Another issue with object oriented programming is impedance mismatch. This
occurs between the relational database and the OOP, which in turn occurs as a
result of difference between the scale and emphasis among operations
performed by databases and objects. Database transactions tend to be much
larger than object oriented programming objects. While databases can be
useful when it comes to storing information among objects, the data related
to the objects should only be stored once data has been summarized and
collected.
The representation of an object should never be added to a database. Because
the objects are small, it doesn't make much sense for OOP to be so complex,
yet it can be said that there is no performance overhead which is created by
object oriented programming. Every domain is modelled independently of the
othersand the scale of the architecture is dependent on the information that
is stored within the database. Another issue associated with OOPs is that of
the connections between the database schemas.
The
paradigm that is to be used dependens on the needs of the person that is
using it. While OOP may be a better approach in some situations, it may not
be the best approach in other.
|